home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 6 / FM Towns Free Software Collection 6.iso / ms_dos / nifp / nifptool.c < prev    next >
Text File  |  1993-07-08  |  25KB  |  1,128 lines
  1. /*
  2.  *    　このﾓｼﾞｭｰﾙは，NIFPのﾌｧｲﾙ選択ｻﾌﾞﾙｰﾁﾝ部です。
  3.  *    　このﾓｼﾞｭｰﾙは，ﾏｼﾝ依存していません。
  4.  *
  5.  *    nifptool.c COPYRIGHT TOOL 1991
  6.  *
  7.  */
  8. #include "nifp.h"
  9.  
  10. #define    GETYEAR(x)    ((((x & 0xfe00) >> 9) + 80) % 100)
  11. #define    GETMONTH(x)    ((x & 0x1e0) >> 5)
  12. #define    GETDATE(x)    (x & 0x1f)
  13. #define    GETHOUR(x)    ((x & 0xf800) >> 11)
  14. #define    GETMIN(x)    ((x & 0x7e0) >> 5)
  15. #define    GETSEC(x)    ((x & 0x1f) << 2)
  16.  
  17.  
  18. /* ﾃﾞｨﾚｸﾄﾘｴﾝﾄﾘ格納ﾃｰﾌﾞﾙの構造体 */
  19. struct    dir_tree {
  20.     struct dir_tree    *next;
  21.     struct dir_tree *back;
  22.     struct ffblk    ffb;
  23. };
  24.  
  25. static int        sel_file(char *);
  26. static int        set_tree(struct ffblk, char *path);
  27. static void        treefree(void);
  28. static int        tree_disp(char *);
  29. static void        init_disp(char *);
  30. static void        filedisp(void);
  31. static void        updownstatus(void);
  32. static void        curdisp(int);
  33. static void        set_fdt(char *, struct dir_tree *);
  34. static int        getsetpath(char *);
  35.  
  36. static void        updown2status(void);
  37. static void        file2disp(void);
  38. static void        cur2disp(int);
  39. static void        set2_fdt(char *,int);
  40.  
  41. static    struct    dir_tree *tree_top = NULL;    /* ﾃｰﾌﾞﾙの先頭 */
  42. static    struct    dir_tree *tree_pos = NULL;    /* ﾃｰﾌﾞﾙの現在（最終）位置 */
  43.  
  44. /* ﾌｧｲﾙ一覧選択画面 */
  45. static    int        fx = 16;    /* 表示位置(桁) */
  46. static    int        fy = 3;        /* 表示位置(行) */
  47. static    int        fn = 10;    /* 表示行       */
  48. static    int        fw = 47;    /* 表示幅       */
  49.  
  50. static    struct dir_tree *cur_top;    /* 表示先頭位置 */
  51. static    struct dir_tree *cur_pos;    /* 表示現在位置 */
  52. static    int        cur_lno;    /* 表示現在行位置 */
  53.  
  54. /* ﾛｸﾞﾌｧｲﾙ選択画面 */
  55. static    int        fx2 = 14;    /* 表示位置(桁) */
  56. static    int        fw2 = 52;    /* 表示幅       */
  57.  
  58. static    int        cur2_top;    /* 表示先頭位置 */
  59. static    int        cur2_pos;    /* 表示現在位置 */
  60. static    int        cur2_lno;    /* 表示現在行位置 */
  61.  
  62. struct    dir2_tree *tree2_top = NULL;    /* ﾃｰﾌﾞﾙの先頭 */
  63. struct    dir2_tree *tree2_pos = NULL;    /* ﾃｰﾌﾞﾙの現在（最終）位置 */
  64.  
  65. void get_fdir(char *f,char *f1) {
  66.     char *a,buf[140];
  67.     int c;
  68.  
  69.     memset(buf,0,140);
  70.     a = buf;
  71.     checkfile(f);
  72.     if(jstrchr(f,':')) {    /* ﾄﾞﾗｲﾌﾞ指定有り */
  73.         c = *f - 'A' + 1;
  74.         *a++ = *f++;
  75.         f++;
  76.     }
  77.     else {
  78.         c = getdisk();
  79.         *a++ = c + 'A';
  80.         c++;
  81.     }
  82.     *a++ = ':';
  83.     if(*f != '\\') {
  84.         *a++ = '\\';
  85.         getcurdir(c,&buf[strlen(buf)]);
  86.         if(buf[strlen(buf)-1] != '\\')
  87.             strcat(&buf[strlen(buf)],"\\");
  88.     }
  89.     strcpy(&buf[strlen(buf)],f);
  90.     strcpy(f1,buf);
  91. }
  92.  
  93. char datfile_s[140];
  94. int datf_src(char *fname,int mode)
  95. {
  96.     int i,k;
  97.     char buf[140],file[140],*w;
  98.  
  99.     k = -1;
  100.     get_fdir(fname,file);    /* ﾌﾙﾊﾟｽ名取得 */
  101.     for(i=0;datf[i];i++) {
  102.         _fstrcpy((char far *)buf,datf[i]);
  103.         if(!(w=jstrchr(buf,' '))) break;
  104.         *w = 0;
  105.         if(strcmp(buf,file)) continue;
  106.         k = i;
  107.         break;
  108.     }
  109.     if(mode) strcpy(datfile_s,file);
  110.     return(k);
  111. }
  112.  
  113. void cgetfsx(char *msg, char *p)
  114. {
  115.     int    err;
  116.  
  117.     while(1) {
  118.         xlocate();
  119.         kprintf(msg);
  120.         cgetsx(p,1);            /* ﾌｧｲﾙ名入力 */
  121.         if(p[2] == 0x1b) {
  122.             p[2] = 0;
  123.             break;                /* ESCｷｰの時には終了 */
  124.         }
  125.         err = sel_file(p);        /* ﾌｧｲﾙ選択処理 */
  126.         p[1] = (char)strlen(&p[2]);
  127.         if(err != -1 && err != S_IFDIR) break;    /* ﾃﾞｨﾚｸﾄﾘでないなら戻る */
  128.         if(p[2+strlen(&p[2])-1] != '\\') {
  129.             strcat(&p[2],"\\");
  130.             p[1]++;
  131.         }
  132.     }
  133.     xlocate();
  134. }
  135.  
  136. static int sel_file(char *p)
  137. {
  138.     struct     ffblk ffb;
  139.     char    path[129],path1[129];
  140.     int    err;
  141.  
  142.     while(1) {
  143.         if(tree_top)                /* ﾃｰﾌﾞﾙ初期化 */
  144.             treefree();
  145.         err = getsetpath(&p[2]);    /* 指定ﾃﾞｨﾚｸﾄﾘの整理 */
  146.         if(err == -1)
  147.             return(err);
  148.         if(err == (int)S_IFREG)        /* 通常ﾌｧｲﾙなら戻る   */
  149.             return(0);
  150.         if(err != S_IFDIR)
  151.             return(err);
  152.         strcpy(path,&p[2]);            /* ﾃｰﾌﾞﾙ作成 */
  153.         if(p[2+strlen(&p[2])-1] != '\\')
  154.             strcat(path,"\\");
  155.         strcpy(path1,path);
  156.         strcat(path,"*.*");
  157.         err = findfirst(path, &ffb,
  158.                 FA_RDONLY|FA_HIDDEN|FA_SYSTEM|FA_DIREC|FA_ARCH);
  159.         if(err) return(-1);
  160.         while (!err) {
  161.             if(strcmp(ffb.ff_name, "."))
  162.                 set_tree(ffb,path1);
  163.             err = findnext(&ffb);
  164.         }
  165.         err = tree_disp(p);        /* 表示・ｷｰ入力処理 */
  166.         if(err == 0x1b)
  167.             return (S_IFDIR);
  168.     }
  169. }
  170.  
  171. static int set_tree(struct ffblk ffdt,char *path)
  172. {
  173.     struct dir_tree *tree_work,*tree_pit;
  174.     long i;
  175.     char fname[129],buf[140];
  176.  
  177.     tree_work = tree_pos;
  178.     tree_pit = (struct dir_tree *)malloc(sizeof(struct dir_tree));
  179.     if(!tree_pit)
  180.         return(-1);
  181.     if(!(ffdt.ff_attrib & FA_DIREC)) {
  182.         strcpy(fname,path);
  183.         strcat(fname,ffdt.ff_name);
  184.         i = datf_src(fname,0);
  185.         if(i != -1) {
  186.             _fstrcpy((char far *)buf,datf[i]);
  187.             if(strstr(buf," @"))
  188.                 ffdt.ff_attrib |= 0x80;
  189.             else
  190.                 ffdt.ff_attrib |= 0x40;
  191.         }
  192.     }
  193.     if(tree_top && fsortmode) {
  194.         for(;tree_work;tree_work=tree_work->back) {
  195.             if(ffdt.ff_attrib & FA_DIREC) {
  196.                 if(!strcmp(tree_work->ffb.ff_name,"..")) break;
  197.                 if(!(tree_work->ffb.ff_attrib & FA_DIREC)) continue;
  198.             }
  199.             else {
  200.                 if(tree_work->ffb.ff_attrib & FA_DIREC) break;
  201.             }
  202.             if(fsortmode >= 3) {
  203.                 i = (long)ffdt.ff_fdate - (long)tree_work->ffb.ff_fdate;
  204.                 if(!i) i = (long)ffdt.ff_ftime - (long)tree_work->ffb.ff_ftime;
  205.                 if(i < 0) {
  206.                     if(fsortmode & 1) continue;
  207.                     break;
  208.                 }
  209.                 if(i > 0) {
  210.                     if(fsortmode & 1) break;
  211.                     continue;
  212.                 }
  213.             }
  214.             i = jstrcmp(ffdt.ff_name,tree_work->ffb.ff_name);
  215.             if(i < 0) {
  216.                 if(fsortmode & 1) continue;
  217.                 break;
  218.             }
  219.             if(fsortmode & 1) break;
  220.         }
  221.     }
  222.     tree_pit->ffb  = ffdt;
  223.     if(!tree_top) {
  224.         tree_top = tree_pos = tree_pit;
  225.         tree_pit->next = tree_pit->back = NULL;
  226.     }
  227.     else if(!tree_work) {
  228.         tree_pit->next = tree_top;
  229.         tree_top->back = tree_pit;
  230.         tree_top = tree_pit;
  231.         tree_pit->back = NULL;
  232.     }
  233.     else if(!tree_work->next) {
  234.         tree_work->next = tree_pos = tree_pit;
  235.         tree_pit->next = NULL;
  236.         tree_pit->back = tree_work;
  237.     }
  238.     else {
  239.         tree_pit->next = tree_work->next;
  240.         tree_work->next = tree_pit;
  241.         tree_pit->back = tree_work;
  242.         tree_pit->next->back = tree_pit;
  243.     }
  244.     return(0);
  245. }
  246.  
  247. static void treefree(void)
  248. {
  249.     struct    dir_tree *work;
  250.     
  251.     while(tree_top) {
  252.         work = tree_top;
  253.         tree_top = tree_top->next;
  254.         free((void *)work);
  255.     }
  256.     tree_top = tree_pos = NULL;
  257. }
  258.  
  259. static int tree_disp(char *p)
  260. {
  261.     char    a,buf[81];
  262.     int        i,j;
  263.     struct dir_tree *cur_wark;
  264.     
  265.     fn = getline() - 6;
  266.     waku_disp(fx,fy,fn,fw,&p[2],"↑,↓,←,→,ﾘﾀｰﾝ,ESC"); /* 枠表示 */
  267.     cur_lno = 1;
  268.     cur_pos = cur_top = tree_top;
  269.     filedisp();
  270.     while (1) {
  271.         updownstatus();
  272.         curdisp(1);
  273.         a = keyget2(0);
  274.         a = cnvpfkey(a);
  275.         curdisp(0);
  276.         switch(a) {
  277.         case UEYA:         /* ↑処理 */
  278.             if(cur_pos == tree_top)    break;
  279.             cur_lno--;
  280.             cur_pos = cur_pos->back;
  281.             if(cur_lno < 1) {
  282.                 cur_lno = 1;
  283.                 cur_top = cur_top->back;
  284.                 scroll(1,fx+1,fy+1,fx+fw,fy+fn);
  285.                 set_fdt(buf, cur_pos);
  286.                 loc(fx+1, fy+cur_lno);
  287.                 deforutoiro();
  288.                 print(buf);
  289.             }
  290.             break;
  291.         case SITAYA:     /* ↓処理 */
  292.             if(!cur_pos->next) break;
  293.             cur_lno++;
  294.             cur_pos = cur_pos->next;
  295.             if(cur_lno > fn) {
  296.                 cur_lno = fn;
  297.                 cur_top = cur_top->next;
  298.                 scroll(0,fx+1,fy+1,fx+fw,fy+fn);
  299.                 set_fdt(buf, cur_pos);
  300.                 loc(fx+1, fy+cur_lno);
  301.                 deforutoiro();
  302.                 print(buf);
  303.             }
  304.             break;
  305.         case HIDARIYA:     /* ←処理 */
  306.             if(cur_pos == tree_top) break;
  307.             if(cur_top == tree_top)
  308.                 cur_pos = tree_top;
  309.             else {
  310.                 for(i = j = 0;i < fn;i++) {
  311.                     if(cur_top == tree_top) {
  312.                         j = 1;
  313.                         break;
  314.                     }
  315.                     cur_top = cur_top->back;
  316.                 }
  317.                 if(j)
  318.                     cur_pos = cur_top;
  319.                 else {
  320.                     for(i = 0;i < fn;i++)
  321.                         cur_pos = cur_pos->back;
  322.                 }
  323.             }
  324.             for(i = 1,cur_wark = cur_top;;i++) {
  325.                 if(cur_pos == cur_wark) break;
  326.                 cur_wark = cur_wark->next;
  327.             }
  328.             cur_lno = i;
  329.             filedisp();
  330.             break;
  331.         case MIGIYA:     /* →処理 */
  332.             if(!cur_pos->next) break;
  333.             cur_wark = cur_top;
  334.             for(i = j = 0;i < fn;i++) {
  335.                 if(!cur_wark->next) {
  336.                     j = 1;
  337.                     break;
  338.                 }
  339.                 cur_wark = cur_wark->next;
  340.             }
  341.             if(j) cur_pos = cur_wark;
  342.             else {
  343.                 for(i = 0;i < fn;i++) cur_top = cur_top->next;
  344.                 for(i = 0;i < fn;i++) {
  345.                     if(!cur_pos->next) break;
  346.                     cur_pos = cur_pos->next;
  347.                 }
  348.             }
  349.             for(i = 1,cur_wark = cur_top;;i++) {
  350.                 if(cur_pos == cur_wark) break;
  351.                 cur_wark = cur_wark->next;
  352.             }
  353.             cur_lno = i;
  354.             filedisp();
  355.             break;
  356.         case KAIGYO:     /* 改行 */
  357.             if(p[2+strlen(&p[2])-1] != '\\')
  358.                 strcat(&p[2],"\\");
  359.             strcat(&p[2],cur_pos->ffb.ff_name);
  360.             return(a);
  361.         case ESC:         /* ＥＳＣ処理 */
  362.             return(a);
  363.         }
  364.     }
  365. }
  366.  
  367. static void filedisp(void)
  368. {
  369.     int    i,j;
  370.     struct dir_tree *wk;
  371.     char    buf[81];
  372.     
  373.     wk = cur_top;
  374.     deforutoiro();
  375.     for(i=0; i<fn; i++) {
  376.         if(!wk) break;
  377.         set_fdt(buf,wk);
  378.         loc(fx+1,fy+1+i);print(buf);
  379.         wk = wk->next;
  380.     }
  381.     for(; i<fn; i++) {
  382.         for(j=0; j<fw; j++) {
  383.             loc(fx+1+j,fy+1+i);print(" ");
  384.         }
  385.     }
  386. }
  387.  
  388. static void updownstatus(void)
  389. {
  390.     int    i,j;
  391.     struct dir_tree *cur_wark;
  392.     
  393.     loc(fx+fw-3,fy+fn+1);
  394.     if(cur_top != tree_top) {
  395.         iro(IUP);print("↑");
  396.     }
  397.     else {
  398.         iro(IFWAKU);print("　");
  399.     }
  400.     cur_wark = cur_top;
  401.     for(i = j = 0;i < fn;i++) {
  402.         if(!cur_wark->next) {
  403.             j = 1;
  404.             break;
  405.         }
  406.         cur_wark = cur_wark->next;
  407.     }
  408.     loc(fx+fw-1,fy+fn+1);
  409.     if(!j) {
  410.         iro(IDOWN);print("↓");
  411.     }
  412.     else {
  413.         iro(IFWAKU);print("　");
  414.     }
  415. }
  416.  
  417. static void curdisp(int c_mode)
  418. {
  419.     char    buf[81];
  420.     
  421.     set_fdt(buf, cur_pos);
  422.     loc(fx+1, fy+cur_lno);
  423.     if(c_mode) iro(IFCUR);
  424.     else       deforutoiro();
  425.     print(buf);
  426. }
  427.  
  428. static void set_fdt(char *ptr, struct dir_tree *tr)
  429. {
  430.     char    wkdt[16],*p,work[50],c;
  431.     char    attr_disp[10]="";
  432.  
  433.     if (tr->ffb.ff_attrib & FA_RDONLY)
  434.         strcat(attr_disp, " R");
  435.     else
  436.         strcat(attr_disp, " _");
  437.     if (tr->ffb.ff_attrib & FA_HIDDEN)
  438.         strcat(attr_disp, " H");
  439.     else
  440.         strcat(attr_disp, " _");
  441.     if (tr->ffb.ff_attrib & FA_SYSTEM)
  442.         strcat(attr_disp, " S");
  443.     else
  444.         strcat(attr_disp, " _");
  445.     if (tr->ffb.ff_attrib & FA_ARCH)
  446.         strcat(attr_disp, " A");
  447.     else
  448.         strcat(attr_disp, " _");
  449.  
  450.     if(tr->ffb.ff_attrib & 0x80) c = '*';
  451.     else if(tr->ffb.ff_attrib & 0x40) c = '+';
  452.     else                      c = ' ';
  453.     if(tr->ffb.ff_attrib & FA_DIREC) {
  454.         strcpy(wkdt,tr->ffb.ff_name);
  455.          strcat(wkdt,"\\");
  456.         sprintf(ptr,"  %-13s  <DIR>",wkdt);
  457.     }
  458.     else {
  459.         strcpy(wkdt, tr->ffb.ff_name);
  460.         if((p = strchr(wkdt,'.'))) {
  461.             *p = NULL;
  462.             sprintf(ptr," %c%-8s.%-3s %7ld",c,wkdt,p+1,tr->ffb.ff_fsize);
  463.         }
  464.         else sprintf(ptr," %c%-8s.    %7ld",c,wkdt,tr->ffb.ff_fsize);
  465.     }
  466.     sprintf(work," %02d-%02d-%02d %02d:%02d %s ", 
  467.         GETYEAR(tr->ffb.ff_fdate),
  468.         GETMONTH(tr->ffb.ff_fdate),
  469.         GETDATE(tr->ffb.ff_fdate),
  470.         GETHOUR(tr->ffb.ff_ftime),
  471.         GETMIN(tr->ffb.ff_ftime),
  472.         attr_disp);
  473.     strcat(ptr,work);
  474. }
  475.  
  476. static int getsetpath(char *ptr)
  477. {
  478.     struct     stat st;
  479.     char    *p1,c_dev,s_dev,c_dir[256],s_dir[256];
  480.     int l;
  481.  
  482.     l = strlen(ptr);
  483.     if(ptr[l-1] == '\\')
  484.         if(l != 1 && ptr[l-2] != ':')
  485.             ptr[l-1] = NULL;
  486.     c_dev = getdisk() + 'A';
  487.     if(!(p1 = jstrchr(ptr,':'))) {    /* ﾄﾞﾗｲﾌﾞ指定なし */
  488.         getcwd(c_dir,255);
  489.         s_dev = c_dev;
  490.         if(strlen(ptr)) {
  491.             if(chdir(ptr)) {        /* ﾃﾞｨﾚｸﾄﾘではない */
  492.                 chdir(c_dir);
  493.                 return(S_IFREG);
  494.             }
  495.         }
  496.         getcwd(s_dir,255);
  497.         chdir(c_dir);
  498.     }
  499.     else {
  500.         s_dev = toupper(*(p1-1));
  501.         setdisk(s_dev - 'A');
  502.         getcwd(c_dir,255);
  503.         if(strlen(p1+1)) {
  504.             if(chdir(p1+1)) {        /* ﾃﾞｨﾚｸﾄﾘではない */
  505.                 setdisk(c_dev - 'A');
  506.                 chdir(c_dir);
  507.                 return(S_IFREG);
  508.             }
  509.             getcwd(s_dir,255);
  510.             setdisk(c_dev - 'A');
  511.             chdir(c_dir);
  512.         }
  513.         else {
  514.             *ptr = s_dev;
  515.             *(ptr+1) = NULL;
  516.             strcat(ptr,":\\");
  517.             strcpy(s_dir,ptr);
  518.         }
  519.         setdisk(c_dev - 'A');
  520.     }
  521.     strcpy(ptr,s_dir);
  522.     if(stat(ptr,&st)) {
  523.         if(!(p1 = strchr(ptr,':'))) return(-1);
  524.         if(*(p1+1) != '\\') return(-1);
  525.         else                return(S_IFDIR);
  526.     }
  527.     if((st.st_mode & S_IFMT) == S_IFDIR) return(S_IFDIR);
  528.     if((st.st_mode & S_IFMT) == S_IFREG) return(S_IFREG);
  529.     return(-1);
  530. }
  531.  
  532. int filechoice(int fno)
  533. {
  534.     char    a,buf[81];
  535.     
  536.     fn = getline() - 6;
  537.     waku_disp(fx2,fy,fn,fw2,"ﾛｸﾞﾌｧｲﾙを選択してください",
  538.      "↑,↓,←,→,ﾘﾀｰﾝ,ESC");
  539.     cur2_lno = fno - ((fno-1) / fn) * fn;
  540.     cur2_top = ((fno-1) / fn) * fn + 1;
  541.     cur2_pos = fno;
  542.     file2disp();
  543.     while (1) {
  544.         updown2status();
  545.         cur2disp(1);
  546.         a = keyget2(0);
  547.         a = cnvpfkey(a);
  548.         cur2disp(0);
  549.         switch(a) {
  550.         case UEYA:         /* ↑処理 */
  551.             if(cur2_pos == 1)    break;
  552.             cur2_lno--;
  553.             cur2_pos--;
  554.             if(cur2_lno < 1) {
  555.                 cur2_lno = 1;
  556.                 cur2_top--;
  557.                 scroll(1,fx2+1,fy+1,fx2+fw2,fy+fn);
  558.                 set2_fdt(buf, cur2_pos);
  559.                 loc(fx2+1, fy+cur2_lno);
  560.                 deforutoiro();
  561.                 print(buf);
  562.             }
  563.             break;
  564.         case SITAYA:     /* ↓処理 */
  565.             if(cur2_pos == maxfno) break;
  566.             cur2_lno++;
  567.             cur2_pos++;
  568.             if(cur2_lno > fn) {
  569.                 cur2_lno = fn;
  570.                 cur2_top++;
  571.                 scroll(0,fx2+1,fy+1,fx2+fw2,fy+fn);
  572.                 set2_fdt(buf, cur2_pos);
  573.                 loc(fx2+1, fy+cur2_lno);
  574.                 deforutoiro();
  575.                 print(buf);
  576.             }
  577.             break;
  578.         case HIDARIYA:     /* ←処理 */
  579.             if(cur2_pos == 1) break;
  580.             if(cur2_top == 1)
  581.                 cur2_pos = cur2_lno = 1;
  582.             else {
  583.                 cur2_top -= fn;
  584.                 cur2_pos -= fn;
  585.                 if(cur2_top < 1)
  586.                     cur2_top = cur2_pos = cur2_lno = 1;
  587.             }
  588.             file2disp();
  589.             break;
  590.         case MIGIYA:     /* →処理 */
  591.             if(cur2_pos == maxfno) break;
  592.             if(cur2_top+fn > maxfno)
  593.                 cur2_pos = maxfno;
  594.             else {
  595.                 cur2_top += fn;
  596.                 cur2_pos += fn;
  597.                 if(cur2_pos >= maxfno)
  598.                     cur2_pos = maxfno;
  599.             }
  600.             cur2_lno = cur2_pos - cur2_top + 1;
  601.             file2disp();
  602.             break;
  603.         case KAIGYO:     /* 改行 */
  604.             return(cur2_pos);
  605.         case ESC:         /* ＥＳＣ */
  606.             return(0);
  607.         }
  608.     }
  609. }
  610.  
  611. static void updown2status(void)
  612. {
  613.     loc(fx2+fw2-3,fy+fn+1);
  614.     if(cur2_top != 1) {
  615.         iro(IUP);print("↑");
  616.     }
  617.     else {
  618.         iro(IFWAKU);print("　");
  619.     }
  620.     loc(fx2+fw2-1,fy+fn+1);
  621.     if(cur2_top+fn <= maxfno) {
  622.         iro(IDOWN);print("↓");
  623.     }
  624.     else {
  625.         iro(IFWAKU);print("　");
  626.     }
  627. }
  628.  
  629. static void file2disp(void)
  630. {
  631.     int        i,j;
  632.     int        wk;
  633.     char    buf[81];
  634.  
  635.     wk = cur2_top;
  636.     deforutoiro();
  637.     for(i=0; i<fn; i++) {
  638.         if(wk > maxfno) break;
  639.         set2_fdt(buf,wk);
  640.         loc(fx2+1,fy+1+i);print(buf);
  641.         wk++;
  642.     }
  643.     for(; i<fn; i++) {
  644.         for(j=0; j<fw2; j++) {
  645.             loc(fx2+1+j,fy+1+i);print(" ");
  646.         }
  647.     }
  648. }
  649.     
  650. static void cur2disp(int c_mode)
  651. {
  652.     char    buf[81];
  653.  
  654.     set2_fdt(buf, cur2_pos);
  655.     loc(fx2+1, fy+cur2_lno);
  656.     if(c_mode) iro(IFCUR);
  657.     else       deforutoiro();
  658.     print(buf);
  659. }
  660.  
  661. static void set2_fdt(char *ptr, int tr)
  662. {
  663.     char *a,buf[21],w1[21],w2[17],ww[129],bufw[140];
  664.     struct stat sbuf;
  665.     struct tm *jtime;
  666.     int i;
  667.     char    attr_disp[10]="";
  668.  
  669.     _fstrcpy((char far *)ww,file[tr-1]);
  670.     if(!(a = strrchr(ww,'\\')) && !(a = strrchr(ww,':')))
  671.         a = ww;
  672.     else a++;
  673.     strcpy(buf,a);
  674.     sprintf(ptr," %3d: ",tr);
  675.     if(stat(ww,&sbuf) || sbuf.st_mode & S_IFDIR) {
  676.         if((a = strchr(buf,'.'))) {
  677.             *a = NULL;
  678.             sprintf(w1," %-8s.%-3s",buf,a+1);
  679.         }
  680.         else sprintf(w1, "%-8s.   ",buf);
  681.         strcat(ptr,w1);
  682.         strcat(ptr,"       ### deleted ###");
  683.     }
  684.     else {
  685.         i = datf_src(ww,0);
  686.         if(i != -1) {
  687.             _fstrcpy((char far *)bufw,datf[i]);
  688.             if(strstr(bufw," @")) strcat(ptr,"*");
  689.             else                  strcat(ptr,"+");
  690.         }
  691.         else strcat(ptr," ");
  692.         if((a = strchr(buf,'.'))) {
  693.             *a = NULL;
  694.             sprintf(w1,"%-8s.%-3s %7ld",buf,a+1,sbuf.st_size);
  695.         }
  696.         else sprintf(w1,"%-8s.    %7ld",buf,sbuf.st_size);
  697.         timezone = 8 * 60 * 60;
  698.         jtime = localtime(&sbuf.st_atime);
  699.         sprintf(w2," %02d-%02d-%02d %02d:%02d",
  700.          jtime->tm_year,jtime->tm_mon+1,jtime->tm_mday,
  701.          jtime->tm_hour,jtime->tm_min);
  702.         strcat(ptr,w1);
  703.         strcat(ptr,w2);
  704.         if(sbuf.st_mode & S_IWRITE)
  705.             strcat(attr_disp, " _");
  706.         else
  707.             strcat(attr_disp, " R");
  708.         strcat(attr_disp, " _ _ A");
  709.         strcat(ptr,attr_disp);
  710.     }
  711.     strncat(ptr,space,fw2-strlen(ptr));
  712.     for(i = 0;ptr[i];i++) {
  713.         if(iskanji(ptr[i]) && iskanji2(ptr[i+1])) {
  714.             i++;
  715.             continue;
  716.         }
  717.         ptr[i] = toupper(ptr[i]);
  718.     }
  719. }
  720.  
  721. int checkfile(char *path)
  722. {
  723.     int i;
  724.     struct stat sbuf;
  725.  
  726.     if(!path) return(0);
  727.     for(i = 0;path[i];i++) {
  728.         if(iskanji(path[i]) && iskanji2(path[i+1])) {
  729.             i++;
  730.             continue;
  731.         }
  732.         path[i] = toupper(path[i]);
  733.     }
  734.     if(stat(path,&sbuf) || (sbuf.st_mode & S_IFDIR))
  735.         return(0);
  736.     if(!sbuf.st_size) return(-1);
  737.     return(1);
  738. }
  739.  
  740. int set2_tree(char *ww)
  741. {
  742.     struct dir2_tree *tree2_work,*tree2_pit;
  743.     long i;
  744.     char *a,buf[21];
  745.     struct stat sbuf;
  746.  
  747.     if(!(a = strrchr(ww,'\\')) && !(a = strrchr(ww,':')))
  748.         a = ww;
  749.     else a++;
  750.     strcpy(buf,a);
  751.     if(stat(ww,&sbuf)) return(-2);
  752.  
  753.     if(!sbuf.st_size) return(-3);
  754.     tree2_work = tree2_pos;
  755.     tree2_pit = (struct dir2_tree *)malloc(sizeof(struct dir2_tree));
  756.     if(!tree2_pit)
  757.         return(-1);
  758.     if(tree2_top && fsort2mode) {
  759.         for(;tree2_work;tree2_work=tree2_work->back) {
  760.             if(fsort2mode >= 3) {
  761.                 i = (long)sbuf.st_atime - (long)tree2_work->sbuf.st_atime;
  762.                 if(i < 0) {
  763.                     if(fsort2mode & 1) continue;
  764.                     break;
  765.                 }
  766.                 if(i > 0) {
  767.                     if(fsort2mode & 1) break;
  768.                     continue;
  769.                 }
  770.             }
  771.             i = jstrcmp(buf,tree2_work->name);
  772.             if(i < 0) {
  773.                 if(fsort2mode & 1) continue;
  774.                 break;
  775.             }
  776.             if(fsort2mode & 1) break;
  777.         }
  778.     }
  779.     tree2_pit->sbuf  = sbuf;
  780.     strcpy(tree2_pit->name,buf);
  781.     tree2_pit->file = (char far *)farmalloc((long)strlen(ww)+1);
  782.     if(tree2_pit->file) _fstrcpy(tree2_pit->file,(char far *)ww);
  783.     if(!tree2_top) {
  784.         tree2_top = tree2_pos = tree2_pit;
  785.         tree2_pit->next = tree2_pit->back = NULL;
  786.     }
  787.     else if(!tree2_work) {
  788.         tree2_pit->next = tree2_top;
  789.         tree2_top->back = tree2_pit;
  790.         tree2_top = tree2_pit;
  791.         tree2_pit->back = NULL;
  792.     }
  793.     else if(!tree2_work->next) {
  794.         tree2_work->next = tree2_pos = tree2_pit;
  795.         tree2_pit->next = NULL;
  796.         tree2_pit->back = tree2_work;
  797.     }
  798.     else {
  799.         tree2_pit->next = tree2_work->next;
  800.         tree2_work->next = tree2_pit;
  801.         tree2_pit->back = tree2_work;
  802.         tree2_pit->next->back = tree2_pit;
  803.     }
  804.     return(0);
  805. }
  806.  
  807. void tree2free(void)
  808. {
  809.     struct    dir2_tree *work;
  810.     
  811.     while(tree2_top != NULL) {
  812.         work = tree2_top;
  813.         tree2_top = tree2_top->next;
  814.         free((void *)work);
  815.     }
  816.     tree2_top = NULL;
  817.     tree2_pos = NULL;
  818. }
  819.  
  820. void set_cmdcopy(char *buf,int c,PCELL far *tcu,char *fname,int lno)
  821. {
  822.     char s[41],w[13],work[81],work1[81],a,w1[9],*o,*p;
  823.     int i,j,k;
  824.     PCELL far *wk;
  825.     char c1=0,c2=0;
  826.     long l;
  827.  
  828.     for(i=j=0;(a=gfilename[i++]) && (a != '.');) {
  829.         w1[j++] = a;
  830.     }
  831.     w1[j] = 0;
  832.     strcpy(s,cmdtbl[c]);
  833.     for(i=j=0;s[i];i++) {
  834.         tbl_set(tcu);
  835.         if(iskanji(s[i]) && iskanji2(s[i+1])) {
  836.             buf[j++] = s[i++];
  837.             buf[j++] = s[i];
  838.             continue;
  839.         }
  840.         if(s[i] == '%') {
  841.             o = &s[i+1];
  842.             if(p = jstrchr(o,'%')) {
  843.                 *p++ = 0;
  844.                 strcpy(work,o);
  845.                 strupr(work);
  846.                 i += strlen(o) + 1;
  847.                 if(o = getenv(work)) {
  848.                     strcpy(&buf[j],o);
  849.                     j += strlen(o);
  850.                 }
  851.                 continue;
  852.             }
  853.         }
  854.         if(s[i] == '$') {
  855.             switch(s[++i]) {
  856.             case 'i':    if(tcu->p->nifid[0]) {
  857.                             _fmemcpy((char far *)&buf[j],tcu->p->nifid,8);
  858.                             k = 8;
  859.                         }
  860.                         else k = 0;
  861.                         break;
  862.             case 'c':    sprintf(w,"%2d",tcu->p->id);
  863.                         memcpy(&buf[j],w,2);
  864.                         k = 2;
  865.                         break;
  866.             case 'f':    strcpy(&buf[j],filename);
  867.                         k = strlen(filename);
  868.                         break;
  869.             case 'X':    strcpy(&buf[j],gfilename);
  870.                         k = strlen(gfilename);
  871.                         break;
  872.             case 'x':    strcpy(&buf[j],w1);
  873.                         k = strlen(w1);
  874.                         break;
  875.             case 'k':    strcpy(&buf[j],kiridir);
  876.                         k = strlen(kiridir);
  877.                         break;
  878.             case 'h':    strcpy(&buf[j],hatudir);
  879.                         k = strlen(hatudir);
  880.                         break;
  881.             case 't':    strcpy(&buf[j],titledir);
  882.                         k = strlen(titledir);
  883.                         break;
  884.             case 'p':    if(strlen(fname)) {
  885.                             strcpy(&buf[j],fname);
  886.                             k = strlen(fname);
  887.                         }
  888.                         else {
  889.                             strcpy(&buf[j],"$p");
  890.                             k = 2;
  891.                         }
  892.                         break;
  893.             case 'P':    if(strlen(fname)) {
  894.                             strcpy(&buf[j],fname);
  895.                             k = strlen(fname);
  896.                         }
  897.                         else {
  898.                             strcpy(&buf[j],"$P");
  899.                             k = 2;
  900.                         }
  901.                         break;
  902.             case 'F':    
  903. set_cmd00:                memset(work,0,9);
  904.                         wk = tcu->grp;
  905.                         tbl_set(wk);
  906.                         _fstrncpy((char far *)work,wk->p->nifid,8);
  907.                         strcpy(&buf[j],work);
  908.                         k = strlen(work);
  909.                         break;
  910.             case 'I':    if(tcu->grp->mode == NHPHEAD)
  911.                             goto set_cmd00;
  912.                         break;
  913.             case 'K':    k = 0;
  914.                         break;
  915.             case 'l':    if(tcu->mode != NSEPA) l = tcu->p->lineno;
  916.                         else {
  917.                             wk = tcu->next;
  918.                             tbl_set(wk);
  919.                             l = wk->p->lineno;
  920.                             tbl_set(tcu);
  921.                         }
  922.                         sprintf(w,"%ld",l + lno - 1);
  923.                         k = strlen(w);
  924.                         strcpy(&buf[j],w);
  925.                         break;
  926.             case 'A':    memset(work,0,9);
  927.                         memset(work1,0,9);
  928.                         wk = tcu->grp;
  929.                         tbl_set(wk);
  930.                         _fstrncpy((char far *)work,wk->p->nifid,8);
  931.                         switch(wk->mode) {
  932.                         case NFBBSHEAD:
  933.                         case NMESHEAD:
  934.                         case NFRTHEAD:
  935.                         case NFRSHEAD:
  936.                         case NLIBHEAD:
  937.                             if(strlen(work) < 7) strcpy(work1,work);
  938.                             else {
  939.                                 strncpy(work1,work,4);
  940.                                 if(strlen(work) < 8)
  941.                                     strcat(&work1[4],&work[5]);
  942.                                 else
  943.                                     strcat(&work1[4],&work[6]);
  944.                             }
  945.                             break;
  946.                         default:
  947.                             strcpy(work1,work);
  948.                         }
  949.                         strcpy(&buf[j],work1);
  950.                         k = strlen(work1);
  951.                         break;
  952.             case 'B':    memset(work,0,9);
  953.                         wk = tcu->grp;
  954.                         tbl_set(wk);
  955.                         k = wk->p->cno;
  956.                         switch(wk->mode) {
  957.                         case NFBBSHEAD:    k = 21;
  958.                         case NMESHEAD:    c1 = '_'; c2 = '~'; break;
  959.                         case NFRTHEAD:
  960.                         case NFRSHEAD:    c1 = '%'; c2 = '&'; break;
  961.                         case NLIBHEAD:    c1 = '#'; c2 = '$'; break;
  962.                         default:        k = -1;
  963.                         }
  964.                         if(k > 0) {
  965.                             work[0] = 0;
  966.                             if(k < 11) {
  967.                                 if(c1) {
  968.                                     if(k != 10) sprintf(work,"%c%d",c1,k);
  969.                                     else        sprintf(work,"%cA",c1);
  970.                                 }
  971.                             }
  972.                             else {
  973.                                 if(c2) {
  974.                                     if(k < 20)     sprintf(work,"%c%d",c2,k-10);
  975.                                     else if(k == 20) sprintf(work,"%cA",c2);
  976.                                     else             sprintf(work,"%cB",c2);
  977.                                 }
  978.                             }
  979.                             strcpy(&buf[j],work);
  980.                         }
  981.                         k = strlen(work);
  982.                         break;
  983.             default:    buf[j] = s[i]; k = 1; break;
  984.             }
  985.             j += k;
  986.             continue;
  987.         }
  988.         buf[j++] = s[i];
  989.     }
  990.     buf[j] = 0;
  991. }
  992.  
  993. static void set_cmdstring(char *buf,int i,PCELL far *tcu,int lno)
  994. {
  995.     char work[256],c;
  996.  
  997.     if(i < 10) c = '0'+i;
  998.     else       c = 'A'+i-10;
  999.     set_cmdcopy(work,i-1,tcu,"",lno);
  1000.     if(cmdtbl[i-1]) sprintf(buf," %c : %s",c,work);
  1001.     else sprintf(buf," %c :",c);
  1002.     strncat(buf,space,72-strlen(buf));
  1003. }
  1004.  
  1005. int comand_disp(PCELL far *tcu,int lno)
  1006. {
  1007.     char    a,b,buf[256];
  1008.     int        i,j;
  1009.     
  1010.     waku_disp(4,3,15,72,
  1011.      "起動ｺﾏﾝﾄﾞを選択してください","数字,A～F,↑,↓,ﾘﾀｰﾝ,ESC");    /* 枠表示 */
  1012.     for(i=1; i<=15; i++) {
  1013.         set_cmdstring(buf,i,tcu,lno);
  1014.         loc(4+1,3+i);print(buf);
  1015.     }
  1016.     for(i=1;;) {
  1017.         set_cmdstring(buf,i,tcu,lno);
  1018.         loc(4+1, 3+i);
  1019.         iro(IFCUR);print(buf);
  1020.         a = keyget2(0);
  1021.         b = cnvpfkey(a);
  1022.         loc(4+1, 3+i);
  1023.         deforutoiro();print(buf);
  1024.         if(a >= 0x81 && a <= 0x8f) {
  1025.             j = (int)(a - 0x81);
  1026.             if(strlen(cmdtbl[j]))
  1027.                 return(j);
  1028.             continue;
  1029.         }
  1030.         if(a >= 'a' && a <= 'f') {
  1031.             j = (int)(a - 'a'+9);
  1032.             if(strlen(cmdtbl[j]))
  1033.                 return(j);
  1034.             continue;
  1035.         }
  1036.         if(a >= 'A' && a <= 'F') {
  1037.             j = (int)(a - 'A'+9);
  1038.             if(strlen(cmdtbl[j]))
  1039.                 return(j);
  1040.             continue;
  1041.         }
  1042.         switch(b) {
  1043.         case UEYA:         /* ↑処理 */
  1044.             if(i <= 1)    break;
  1045.             i--;
  1046.             break;
  1047.         case SITAYA:     /* ↓処理 */
  1048.             if(i >= 15) break;
  1049.             i++;
  1050.             break;
  1051.         case KAIGYO:     /* 改行 */
  1052.             if(!strlen(cmdtbl[i-1])) break;
  1053.             return(i-1);
  1054.         case ESC:         /* ＥＳＣ処理 */
  1055.             return(-1);
  1056.         }
  1057.     }
  1058. }
  1059.  
  1060. void waku_disp(int x,int y,int n,int w,char *ptr,char *ptr1)
  1061. {
  1062.     int    i, j;
  1063.     char buf[81];
  1064.  
  1065.     loc(x-1,y);deforutoiro();print(" ");
  1066.     iro(IFWAKU);
  1067. /*    for(i=0; i<(w+2); i++) {
  1068.         buf[i] = ' ';
  1069.     }
  1070.     buf[i] = 0; */
  1071.     xxstrncpy(buf,space,w+2);
  1072.     loc(x,y);print(buf);
  1073.     loc(x+w+2,y);deforutoiro();print(" ");
  1074.     loc(x+1,y);iro(IFWAKU);print(ptr);
  1075.     xxstrncpy(buf,space,w);
  1076.     for(i=y+1; i<(y+n+1); i++) {
  1077.         loc(x-1,i);deforutoiro();print(" ");
  1078.         loc(x,i);iro(IFWAKU);print(" ");
  1079.         deforutoiro();
  1080. /*        for(j=0; j<w; j++) {
  1081.             buf[j] = ' ';
  1082.         } */
  1083.         loc(x+1,i);print(buf);
  1084.         loc(x+w+1,i);iro(IFWAKU);print(" ");
  1085.         loc(x+w+2,i);deforutoiro();print(" ");
  1086.     }
  1087.     loc(x-1,y+n+1);deforutoiro();print(" ");
  1088.     iro(IFWAKU);
  1089. /*    for(i=0; i<(w+2); i++) {
  1090.         buf[i] = ' ';
  1091.     } */
  1092.     xxstrncpy(buf,space,w+2);
  1093.     loc(x,y+n+1);print(buf);
  1094.     loc(x+w+2,y+n+1);deforutoiro();print(" ");
  1095.     i = x + w - strlen(ptr1) - 4;
  1096.     loc(i,y+n+1);iro(IFWAKU);print(ptr1);
  1097.     deforutoiro();
  1098. }
  1099.  
  1100. static char *grh_string="|----+----+----+----+----+----+----+----+----+----|";
  1101. void grh_disp(char *ptr,int mode) {
  1102.     waku_disp(12,8,3,55,ptr,mode ? "ESCｷｰで中断" : "");
  1103.     loc(14,9);
  1104.     print("0%   10   20   30   40   50   60   70   80   90  100%");
  1105.     loc(14,10);
  1106.     print(grh_string);
  1107. }
  1108.  
  1109. void grh_sub(long nn,long tt) {
  1110.     unsigned long i,n,t;
  1111.     char buf[51];
  1112.  
  1113.     n = nn;
  1114.     t = tt;
  1115.     if(n && t) {
  1116.         i = (n * 50)/ t;
  1117.         memset(buf,0,51);
  1118.         strncpy(buf,grh_string+1,i);
  1119.         loc(15,10);iro(ITITLE);
  1120.         print(buf);
  1121.         deforutoiro();
  1122.     }
  1123.     else {
  1124.         loc(14,10);
  1125.         print(grh_string);
  1126.     }
  1127. }
  1128.